'use strict';

const RpcClient = require('./rpcClient');
const RpcProxy = require('./rpcProxy');

/**
 * RPC服务注册表，用于管理全局服务和代理
 */
class RpcRegistry {
  constructor() {
    this.services = new Map();
    this.proxies = new Map();

    // 全局服务代理对象
    global.services = global.services || {};

    // 非全局服务代理对象
    global.RPC = global.RPC || {};
  }

  /**
   * 获取单例
   * @returns {RpcRegistry} 注册表实例
   */
  static getInstance() {
    if (!RpcRegistry.instance) {
      RpcRegistry.instance = new RpcRegistry();
    }
    return RpcRegistry.instance;
  }

  /**
   * 初始化RPC代理
   * @param {Object} options 初始化选项
   * @returns {Promise<void>}
   */
  async initializeRpcProxy(options = {}) {
    try {
      // 初始化代理
      const rpcProxy = await RpcProxy.initialize(options);

      // 设置全局RPC对象
      global.RPC = rpcProxy;

      console.log('[Registry] RPC代理初始化完成');
    } catch (error) {
      console.error('[Registry] 初始化RPC代理失败:', error);
      throw error;
    }
  }

  /**
   * 刷新RPC代理配置
   * @returns {Promise<boolean>} 是否成功
   */
  async refreshRpcProxy() {
    try {
      // 重新初始化代理
      await this.initializeRpcProxy();
      console.log('[Registry] RPC代理刷新完成');
      return true;
    } catch (error) {
      console.error('[Registry] 刷新RPC代理失败:', error);
      return false;
    }
  }

  /**
   * 注册本地服务
   * @param {string} serviceName 服务名称
   * @param {object} serviceInstance 服务实例
   * @param {boolean} isGlobal 是否为全局服务
   */
  registerLocalService(serviceName, serviceInstance, isGlobal = false) {
    this.services.set(serviceName, serviceInstance);

    if (isGlobal) {
      // 注册为全局服务
      global[serviceName] = serviceInstance;

      // 添加到global.services
      global.services[serviceName] = serviceInstance;

      console.log(`[Registry] 服务 ${serviceName} 已注册为全局服务`);
    } else {
      console.log(`[Registry] 服务 ${serviceName} 已注册为本地服务`);
    }
  }

  /**
   * 获取服务代理
   * @param {string} serviceName 服务名称
   * @param {number} port 端口号
   * @param {string} host 主机地址
   * @returns {Proxy} 服务代理
   */
  getService(serviceName, port, host = 'localhost') {
    const key = `${serviceName}:${port}`;

    if (!this.proxies.has(key)) {
      // 创建延迟代理，只有在调用方法时才连接
      const client = new RpcClient(serviceName, port, host);
      this.proxies.set(key, client);

      // 注册实例，但不建立连接
      RpcProxy.registerInstance(serviceName, port);
    }

    return this.proxies.get(key);
  }

  /**
   * 获取本地服务
   * @param {string} serviceName 服务名称
   * @returns {object|null} 服务实例或null
   */
  getLocalService(serviceName) {
    return this.services.get(serviceName) || null;
  }

  /**
   * 检查服务是否存在
   * @param {string} serviceName 服务名称
   * @returns {boolean} 是否存在
   */
  hasService(serviceName) {
    return this.services.has(serviceName);
  }
}

// 单例实例
RpcRegistry.instance = null;

module.exports = RpcRegistry.getInstance(); 